{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "说明：以下按头文件分类列出 **C++23** 可用的线程同步与并发工具，并标注首次引入的标准版本（若早于 C++23 仍保留以便查阅）。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# `<thread>` —— 线程与调度\n",
    "\n",
    "| 组件                                                         | 版本  | 作用                                             |\n",
    "| ------------------------------------------------------------ | ----- | ------------------------------------------------ |\n",
    "| `std::thread`                                                | C++11 | 基础线程对象。                                   |\n",
    "| `std::jthread`                                               | C++20 | RAII 线程，自动 `join`，集成 `std::stop_token`。 |\n",
    "| `std::this_thread::get_id` / `yield` / `sleep_for` / `sleep_until` | C++11 | 当前线程操作。                                   |\n",
    "| `std::this_thread::notify_all_at_thread_exit`                | C++11 | 线程结束时唤醒等待的条件变量。                   |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# `<mutex>` —— 基础互斥原语与锁管理\n",
    "\n",
    "| 组件                                                         | 版本  | 作用                             |\n",
    "| ------------------------------------------------------------ | ----- | -------------------------------- |\n",
    "| `std::mutex`, `std::recursive_mutex`                         | C++11 | 普通/可重入互斥量。              |\n",
    "| `std::timed_mutex`, `std::recursive_timed_mutex`             | C++11 | 带超时的互斥量。                 |\n",
    "| `std::lock_guard`, `std::unique_lock`                        | C++11 | RAII 锁管理器。                  |\n",
    "| `std::scoped_lock`                                           | C++17 | 一次性锁定多个互斥量，避免死锁。 |\n",
    "| `std::lock`, `std::try_lock`, `std::adopt_lock_t`, `std::defer_lock_t`, `std::try_to_lock_t` | C++11 | 低层锁协调辅助工具。             |\n",
    "| `std::once_flag`, `std::call_once`                           | C++11 | 一次性初始化保障。               |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# `<shared_mutex>` —— 读写锁与共享锁\n",
    "\n",
    "| 组件                      | 版本  | 作用                 |\n",
    "| ------------------------- | ----- | -------------------- |\n",
    "| `std::shared_mutex`       | C++17 | 多读单写互斥锁。     |\n",
    "| `std::shared_timed_mutex` | C++14 | 带超时的共享互斥锁。 |\n",
    "| `std::shared_lock`        | C++17 | 读锁 RAII 管理器。   |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# `<condition_variable>` —— 条件同步\n",
    "\n",
    "| 组件                          | 版本  | 作用                           |\n",
    "| ----------------------------- | ----- | ------------------------------ |\n",
    "| `std::condition_variable`     | C++11 | 仅配合 `std::mutex` 使用。     |\n",
    "| `std::condition_variable_any` | C++11 | 兼容任意满足互斥语义的锁对象。 |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# `<semaphore>` —— 信号量（C++20）\n",
    "\n",
    "| 组件                                     | 版本  | 作用                                                        |\n",
    "| ---------------------------------------- | ----- | ----------------------------------------------------------- |\n",
    "| `std::counting_semaphore<LeastMaxValue>` | C++20 | 计数信号量，支持 `acquire`/`release`/`try_acquire_for` 等。 |\n",
    "| `std::binary_semaphore`                  | C++20 | 退化为 0/1 信号量。                                         |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# `<latch>` 与 `<barrier>` —— 闩锁与栅栏（C++20）\n",
    "\n",
    "| 组件           | 版本  | 作用                                   |\n",
    "| -------------- | ----- | -------------------------------------- |\n",
    "| `std::latch`   | C++20 | 一次性同步点，计数减至 0 时释放。      |\n",
    "| `std::barrier` | C++20 | 可重复使用的栅栏，支持到达时执行回调。 |\n",
    "\n",
    "这两个都是 C++20 引入的“阶段性同步”原语，用于协调一组线程在某个同步点上“集合”，待条件满足后再继续执行。\n",
    "\n",
    "\n",
    "闩锁（Latch）\n",
    "\n",
    "- **一次性** 计数同步器。\n",
    "- 构造时指定一个计数值 `count`。每当线程调用 `count_down()`（或 `arrive()`）时，`count` 减 1。\n",
    "- 当计数减到 0，所有等待 `wait()` 的线程被唤醒，而后闩锁不可重置。\n",
    "- 当作“倒计时发令枪”：多线程完成某项任务后调用 `count_down()`，最后一个线程到达时，等待者同时“起跑”。\n",
    "\n",
    "栅栏（Barrier）\n",
    "\n",
    "- **可重复使用** 的阶段同步器。\n",
    "- 每批线程到达同步点时调用 `arrive_and_wait()`（或 `arrive()` + `wait()`），当到齐后，栅栏执行可选的完成回调并重新进入下一阶段。\n",
    "- 可用于多轮次迭代的“阶段控制”。例如并行算法里的每次迭代都需要所有线程处理完当前分块，再统一进入下一轮。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# `<stop_token>` —— 可取消协作机制（C++20）\n",
    "\n",
    "| 组件                 | 版本  | 作用                 |\n",
    "| -------------------- | ----- | -------------------- |\n",
    "| `std::stop_token`    | C++20 | 线程协作式取消标志。 |\n",
    "| `std::stop_source`   | C++20 | 发起取消请求。       |\n",
    "| `std::stop_callback` | C++20 | 注册回调以响应取消。 |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# `<future>` —— 异步结果与任务\n",
    "\n",
    "| 组件                                         | 版本  | 作用                                |\n",
    "| -------------------------------------------- | ----- | ----------------------------------- |\n",
    "| `std::future`, `std::shared_future`          | C++11 | 获取异步结果（一次性 / 多次取值）。 |\n",
    "| `std::promise`, `std::packaged_task`         | C++11 | 手动写入异步结果；封装可调用对象。  |\n",
    "| `std::async`                                 | C++11 | 启动异步任务（惰性/立即）。         |\n",
    "| `std::future_status`, `std::future_error` 等 | C++11 | 状态管理与异常。                    |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# `<atomic>` —— 原子操作与内存序\n",
    "\n",
    "| 组件                                                         | 版本  | 作用                                                     |\n",
    "| ------------------------------------------------------------ | ----- | -------------------------------------------------------- |\n",
    "| `std::atomic<T>`（适用 trivially copyable 类型）             | C++11 | 原子封装，支持 load/store/exchange/compare_exchange 等。 |\n",
    "| `std::atomic<bool>`, `std::atomic_flag`                      | C++11 | 最简单的原子位。C++20 补充 `wait/notify`。               |\n",
    "| `std::atomic_ref<T>`                                         | C++20 | 对既有对象施加原子语义。                                 |\n",
    "| `std::atomic_thread_fence`, `std::atomic_signal_fence`       | C++11 | 插入内存栅栏。                                           |\n",
    "| `std::atomic_wait`, `std::atomic_wait_explicit`              | C++20 | 在原子值满足条件前阻塞当前线程。                         |\n",
    "| `std::atomic_notify_one`, `std::atomic_notify_all`           | C++20 | 唤醒等待原子值的线程。                                   |\n",
    "| `std::atomic<T>::notify_all_at_thread_exit`                  | C++20 | 当前线程退出时唤醒等待者。                               |\n",
    "| `std::atomic_flag::test`, `test_and_set`, `clear`, `wait`, `notify_one` 等 | C++20 | 针对自旋锁等场景的低层原语。                             |\n",
    "| `std::atomic<shared_ptr<T>>`, `std::atomic<weak_ptr<T>>`     | C++20 | 对智能指针的原子操作特化。                               |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# `<syncstream>` —— 流式输出同步（C++20）\n",
    "\n",
    "| 组件                               | 版本  | 作用                                   |\n",
    "| ---------------------------------- | ----- | -------------------------------------- |\n",
    "| `std::osyncstream`, `std::syncbuf` | C++20 | 多线程打印时保证完整输出片段，不交错。 |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# `<barrier>` 扩展：阶段性控制（C++23 细化）\n",
    "\n",
    "C++23 对 `std::barrier` 做了细化（如更好地支持 `arrival_token` 的移动构造、`phase_completion` 回调约束等），但接口总体保持 C++20 形态。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# `<chrono>` —— 定时与时钟\n",
    "\n",
    "| 组件                                                         | 版本  | 作用                     |\n",
    "| ------------------------------------------------------------ | ----- | ------------------------ |\n",
    "| `std::chrono::steady_clock`, `system_clock`, `high_resolution_clock` | C++11 | 供超时等待、sleep 使用。 |\n",
    "| `std::chrono::sleep_for`, `sleep_until`（在 `std::this_thread` 中） | C++11 | 线程休眠。               |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# `<barrier>`/`<latch>` 之外的协作构件\n",
    "\n",
    "| 组件                                                         | 版本  | 作用                                                      |\n",
    "| ------------------------------------------------------------ | ----- | --------------------------------------------------------- |\n",
    "| `std::hardware_constructive_interference_size`, `std::hardware_destructive_interference_size`（`<new>`） | C++17 | 帮助设计避免 false sharing 的缓存布局。                   |\n",
    "| `std::atomic_flag`, `std::spinlock`（自实现）                | —     | 标准未提供直接的自旋锁类型，但可使用 `atomic_flag` 构建。 |\n",
    "| `std::notify_all_at_thread_exit`（`<condition_variable>`）   | C++11 | 线程结束时自动通知。                                      |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 组合工具与辅助函数\n",
    "\n",
    "- `std::try_lock`, `std::lock`（多互斥量协调）\n",
    "- `std::unique_lock` 的 `try_lock_for`, `try_lock_until`（配合 `timed_mutex`）\n",
    "- `std::shared_lock` 的超时成员函数\n",
    "- `std::chrono` 时间段与锁超时结合\n",
    "- `std::atomic<T>` 系列的 `fetch_add`, `fetch_sub`, `fetch_or`, `fetch_xor`, `fetch_and`\n",
    "- 各类原子的 `is_lock_free()` 查询\n",
    "- `std::execution::par`, `std::execution::par_unseq`, `std::execution::seq`, `std::execution::unseq`（C++17）\n",
    "\n",
    "  > **注意**：执行策略只影响算法调度，不提供容器级线程安全，算法体仍需自行同步。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# C++23 之后的新增动向（展望）\n",
    "\n",
    "- C++23 已通过的并发扩展集中在标准一致性补丁、对现有原语的 bugfix、与 ranges/format 等库的融合。\n",
    "- 后续提案（如 Executors、Hazard Pointers、Transactional Memory）仍在标准化进程中，尚未进入 C++23。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 使用建议\n",
    "\n",
    "1. **写操作需显式同步**：标准容器对并发写不做保证。\n",
    "2. **优先使用 RAII 锁**：`std::lock_guard`/`std::unique_lock`/`std::scoped_lock`。\n",
    "3. **多线程取消**：优先考虑 `std::jthread` + `std::stop_token`，避免裸线程泄漏。\n",
    "4. **减少忙等**：用条件变量、信号量、`atomic_wait` 等阻塞式等待。\n",
    "5. **原子 wait/notify**：对轻量 flag 的等待优于条件变量。\n",
    "6. **线程安全输出**：借助 `std::osyncstream` 聚合输出，避免日志交织。\n",
    "7. **合理选择工具**：简单场景用互斥锁；高并发下可用信号量/栅栏；跨线程结果传递用 future/promise 或 channel（自实现）。\n",
    "\n",
    "> 将这些工具配套使用，结合 C++ 内存模型规范，就能在 C++23 中打造健壮、安全、可扩展的并发系统。"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "C++17",
   "language": "C++17",
   "name": "xcpp17"
  },
  "language_info": {
   "name": "C++17"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
